// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.ship.plans.sub;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.ShipPlansSub;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(ShipPlansSub.class)
@Setter
@Getter
public class ShipPlansSubSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "ShipPlansSub".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("parentShipPlans", "sp");
    map.put("productId", "p");
    map.put("shopId", "si");
    map.put("logisticsBusinessId", "lp");
    map.put("logisticsChannel", "lc");
    map.put("deliveryWarehouseId", "w");
    map.put("deliveryWarehouseStoreId", "si2");
    map.put("deliveryWarehouseStoreFnsku", "lf");
    map.put("lockBin", "wb");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 所属发货计划单
   */
  private Long parentShipPlans;

  /**
   * 所属发货计划单 比较(eq)
   */
  private Long parentShipPlansEq;
  /**
   * 所属发货计划单 比较(neq)
   */
  private Long parentShipPlansNeq;
  /**
   * 所属发货计划单 比较(gt)
   */
  private Long parentShipPlansGt;
  /**
   * 所属发货计划单 比较(gte)
   */
  private Long parentShipPlansGte;
  /**
   * 所属发货计划单 比较(lt)
   */
  private Long parentShipPlansLt;
  /**
   * 所属发货计划单 比较(lte)
   */
  private Long parentShipPlansLte;
  /**
   * 所属发货计划单 比较(contains)
   */
  private Long parentShipPlansContains;
  /**
   * 所属发货计划单 比较(notcontains)
   */
  private Long parentShipPlansNotcontains;
  /**
   * 所属发货计划单 比较(startswith)
   */
  private Long parentShipPlansStartswith;
  /**
   * 所属发货计划单 比较(endswith)
   */
  private Long parentShipPlansEndswith;
  /**
   * 所属发货计划单 比较(isnull)
   */
  private Boolean parentShipPlansIsnull;
  /**
   * 所属发货计划单 比较(isnotnull)
   */
  private Boolean parentShipPlansIsnotnull;
  /**
   * 所属发货计划单的创建批次号 比较(eq)
   */
  private String parentShipPlansCreateBatchNumberEq;
  /**
   * 所属发货计划单的创建批次号 比较(neq)
   */
  private String parentShipPlansCreateBatchNumberNeq;
  /**
   * 所属发货计划单的创建批次号 比较(gt)
   */
  private String parentShipPlansCreateBatchNumberGt;
  /**
   * 所属发货计划单的创建批次号 比较(gte)
   */
  private String parentShipPlansCreateBatchNumberGte;
  /**
   * 所属发货计划单的创建批次号 比较(lt)
   */
  private String parentShipPlansCreateBatchNumberLt;
  /**
   * 所属发货计划单的创建批次号 比较(lte)
   */
  private String parentShipPlansCreateBatchNumberLte;
  /**
   * 所属发货计划单的创建批次号 比较(contains)
   */
  private String parentShipPlansCreateBatchNumberContains;
  /**
   * 所属发货计划单的创建批次号 比较(notcontains)
   */
  private String parentShipPlansCreateBatchNumberNotcontains;
  /**
   * 所属发货计划单的创建批次号 比较(startswith)
   */
  private String parentShipPlansCreateBatchNumberStartswith;
  /**
   * 所属发货计划单的创建批次号 比较(endswith)
   */
  private String parentShipPlansCreateBatchNumberEndswith;
  /**
   * 所属发货计划单的创建批次号 比较(isnull)
   */
  private Boolean parentShipPlansCreateBatchNumberIsnull;
  /**
   * 所属发货计划单的创建批次号 比较(isnotnull)
   */
  private Boolean parentShipPlansCreateBatchNumberIsnotnull;

  /**
   * 所属发货计划单(范围搜索)
   */
  private List<Long> parentShipPlansInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 计划编号(模糊搜索)
   */
  private String orderSn;

  /**
   * 计划编号 比较(eq)
   */
  private String orderSnEq;
  /**
   * 计划编号 比较(neq)
   */
  private String orderSnNeq;
  /**
   * 计划编号 比较(gt)
   */
  private String orderSnGt;
  /**
   * 计划编号 比较(gte)
   */
  private String orderSnGte;
  /**
   * 计划编号 比较(lt)
   */
  private String orderSnLt;
  /**
   * 计划编号 比较(lte)
   */
  private String orderSnLte;
  /**
   * 计划编号 比较(contains)
   */
  private String orderSnContains;
  /**
   * 计划编号 比较(notcontains)
   */
  private String orderSnNotcontains;
  /**
   * 计划编号 比较(startswith)
   */
  private String orderSnStartswith;
  /**
   * 计划编号 比较(endswith)
   */
  private String orderSnEndswith;
  /**
   * 计划编号 比较(isnull)
   */
  private Boolean orderSnIsnull;
  /**
   * 计划编号 比较(isnotnull)
   */
  private Boolean orderSnIsnotnull;

  /**
   * 计划编号(精确搜索)
   */
  private List<String> orderSnInList;

  /**
   * 是否有 图片
   */
  private Boolean img;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * FNSKU(模糊搜索)
   */
  private String fnsku;

  /**
   * FNSKU 比较(eq)
   */
  private String fnskuEq;
  /**
   * FNSKU 比较(neq)
   */
  private String fnskuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private String fnskuGt;
  /**
   * FNSKU 比较(gte)
   */
  private String fnskuGte;
  /**
   * FNSKU 比较(lt)
   */
  private String fnskuLt;
  /**
   * FNSKU 比较(lte)
   */
  private String fnskuLte;
  /**
   * FNSKU 比较(contains)
   */
  private String fnskuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private String fnskuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private String fnskuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private String fnskuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnskuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnskuIsnotnull;

  /**
   * FNSKU(精确搜索)
   */
  private List<String> fnskuInList;

  /**
   * ASIN(模糊搜索)
   */
  private String asin;

  /**
   * ASIN 比较(eq)
   */
  private String asinEq;
  /**
   * ASIN 比较(neq)
   */
  private String asinNeq;
  /**
   * ASIN 比较(gt)
   */
  private String asinGt;
  /**
   * ASIN 比较(gte)
   */
  private String asinGte;
  /**
   * ASIN 比较(lt)
   */
  private String asinLt;
  /**
   * ASIN 比较(lte)
   */
  private String asinLte;
  /**
   * ASIN 比较(contains)
   */
  private String asinContains;
  /**
   * ASIN 比较(notcontains)
   */
  private String asinNotcontains;
  /**
   * ASIN 比较(startswith)
   */
  private String asinStartswith;
  /**
   * ASIN 比较(endswith)
   */
  private String asinEndswith;
  /**
   * ASIN 比较(isnull)
   */
  private Boolean asinIsnull;
  /**
   * ASIN 比较(isnotnull)
   */
  private Boolean asinIsnotnull;

  /**
   * ASIN(精确搜索)
   */
  private List<String> asinInList;

  /**
   * 父ASIN(模糊搜索)
   */
  private String parentasin;

  /**
   * 父ASIN 比较(eq)
   */
  private String parentasinEq;
  /**
   * 父ASIN 比较(neq)
   */
  private String parentasinNeq;
  /**
   * 父ASIN 比较(gt)
   */
  private String parentasinGt;
  /**
   * 父ASIN 比较(gte)
   */
  private String parentasinGte;
  /**
   * 父ASIN 比较(lt)
   */
  private String parentasinLt;
  /**
   * 父ASIN 比较(lte)
   */
  private String parentasinLte;
  /**
   * 父ASIN 比较(contains)
   */
  private String parentasinContains;
  /**
   * 父ASIN 比较(notcontains)
   */
  private String parentasinNotcontains;
  /**
   * 父ASIN 比较(startswith)
   */
  private String parentasinStartswith;
  /**
   * 父ASIN 比较(endswith)
   */
  private String parentasinEndswith;
  /**
   * 父ASIN 比较(isnull)
   */
  private Boolean parentasinIsnull;
  /**
   * 父ASIN 比较(isnotnull)
   */
  private Boolean parentasinIsnotnull;

  /**
   * 父ASIN(精确搜索)
   */
  private List<String> parentasinInList;

  /**
   * 产品
   */
  private Long productId;

  /**
   * 产品 比较(eq)
   */
  private Long productIdEq;
  /**
   * 产品 比较(neq)
   */
  private Long productIdNeq;
  /**
   * 产品 比较(gt)
   */
  private Long productIdGt;
  /**
   * 产品 比较(gte)
   */
  private Long productIdGte;
  /**
   * 产品 比较(lt)
   */
  private Long productIdLt;
  /**
   * 产品 比较(lte)
   */
  private Long productIdLte;
  /**
   * 产品 比较(contains)
   */
  private Long productIdContains;
  /**
   * 产品 比较(notcontains)
   */
  private Long productIdNotcontains;
  /**
   * 产品 比较(startswith)
   */
  private Long productIdStartswith;
  /**
   * 产品 比较(endswith)
   */
  private Long productIdEndswith;
  /**
   * 产品 比较(isnull)
   */
  private Boolean productIdIsnull;
  /**
   * 产品 比较(isnotnull)
   */
  private Boolean productIdIsnotnull;
  /**
   * 产品的品名 比较(eq)
   */
  private String productIdNameEq;
  /**
   * 产品的品名 比较(neq)
   */
  private String productIdNameNeq;
  /**
   * 产品的品名 比较(gt)
   */
  private String productIdNameGt;
  /**
   * 产品的品名 比较(gte)
   */
  private String productIdNameGte;
  /**
   * 产品的品名 比较(lt)
   */
  private String productIdNameLt;
  /**
   * 产品的品名 比较(lte)
   */
  private String productIdNameLte;
  /**
   * 产品的品名 比较(contains)
   */
  private String productIdNameContains;
  /**
   * 产品的品名 比较(notcontains)
   */
  private String productIdNameNotcontains;
  /**
   * 产品的品名 比较(startswith)
   */
  private String productIdNameStartswith;
  /**
   * 产品的品名 比较(endswith)
   */
  private String productIdNameEndswith;
  /**
   * 产品的品名 比较(isnull)
   */
  private Boolean productIdNameIsnull;
  /**
   * 产品的品名 比较(isnotnull)
   */
  private Boolean productIdNameIsnotnull;

  /**
   * 产品(范围搜索)
   */
  private List<Long> productIdInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 店铺
   */
  private Long shopId;

  /**
   * 店铺 比较(eq)
   */
  private Long shopIdEq;
  /**
   * 店铺 比较(neq)
   */
  private Long shopIdNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long shopIdGt;
  /**
   * 店铺 比较(gte)
   */
  private Long shopIdGte;
  /**
   * 店铺 比较(lt)
   */
  private Long shopIdLt;
  /**
   * 店铺 比较(lte)
   */
  private Long shopIdLte;
  /**
   * 店铺 比较(contains)
   */
  private Long shopIdContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long shopIdNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long shopIdStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long shopIdEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean shopIdIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean shopIdIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String shopIdShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String shopIdShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String shopIdShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String shopIdShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String shopIdShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String shopIdShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String shopIdShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String shopIdShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String shopIdShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String shopIdShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean shopIdShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean shopIdShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> shopIdInList;

  /**
   * 计划发货量
   */
  private Long plannedShipment;

  /**
   * 最小计划发货量
   */
  private Long plannedShipmentMin;

  /**
   * 最大计划发货量
   */
  private Long plannedShipmentMax;

  /**
   * 计划发货量 比较(eq)
   */
  private Long plannedShipmentEq;
  /**
   * 计划发货量 比较(neq)
   */
  private Long plannedShipmentNeq;
  /**
   * 计划发货量 比较(gt)
   */
  private Long plannedShipmentGt;
  /**
   * 计划发货量 比较(gte)
   */
  private Long plannedShipmentGte;
  /**
   * 计划发货量 比较(lt)
   */
  private Long plannedShipmentLt;
  /**
   * 计划发货量 比较(lte)
   */
  private Long plannedShipmentLte;
  /**
   * 计划发货量 比较(contains)
   */
  private Long plannedShipmentContains;
  /**
   * 计划发货量 比较(notcontains)
   */
  private Long plannedShipmentNotcontains;
  /**
   * 计划发货量 比较(startswith)
   */
  private Long plannedShipmentStartswith;
  /**
   * 计划发货量 比较(endswith)
   */
  private Long plannedShipmentEndswith;
  /**
   * 计划发货量 比较(isnull)
   */
  private Boolean plannedShipmentIsnull;
  /**
   * 计划发货量 比较(isnotnull)
   */
  private Boolean plannedShipmentIsnotnull;

  /**
   * 总计发货量
   */
  private Long totalShipment;

  /**
   * 最小总计发货量
   */
  private Long totalShipmentMin;

  /**
   * 最大总计发货量
   */
  private Long totalShipmentMax;

  /**
   * 总计发货量 比较(eq)
   */
  private Long totalShipmentEq;
  /**
   * 总计发货量 比较(neq)
   */
  private Long totalShipmentNeq;
  /**
   * 总计发货量 比较(gt)
   */
  private Long totalShipmentGt;
  /**
   * 总计发货量 比较(gte)
   */
  private Long totalShipmentGte;
  /**
   * 总计发货量 比较(lt)
   */
  private Long totalShipmentLt;
  /**
   * 总计发货量 比较(lte)
   */
  private Long totalShipmentLte;
  /**
   * 总计发货量 比较(contains)
   */
  private Long totalShipmentContains;
  /**
   * 总计发货量 比较(notcontains)
   */
  private Long totalShipmentNotcontains;
  /**
   * 总计发货量 比较(startswith)
   */
  private Long totalShipmentStartswith;
  /**
   * 总计发货量 比较(endswith)
   */
  private Long totalShipmentEndswith;
  /**
   * 总计发货量 比较(isnull)
   */
  private Boolean totalShipmentIsnull;
  /**
   * 总计发货量 比较(isnotnull)
   */
  private Boolean totalShipmentIsnotnull;

  /**
   * 差异量
   */
  private Long differenceQuantity;

  /**
   * 最小差异量
   */
  private Long differenceQuantityMin;

  /**
   * 最大差异量
   */
  private Long differenceQuantityMax;

  /**
   * 差异量 比较(eq)
   */
  private Long differenceQuantityEq;
  /**
   * 差异量 比较(neq)
   */
  private Long differenceQuantityNeq;
  /**
   * 差异量 比较(gt)
   */
  private Long differenceQuantityGt;
  /**
   * 差异量 比较(gte)
   */
  private Long differenceQuantityGte;
  /**
   * 差异量 比较(lt)
   */
  private Long differenceQuantityLt;
  /**
   * 差异量 比较(lte)
   */
  private Long differenceQuantityLte;
  /**
   * 差异量 比较(contains)
   */
  private Long differenceQuantityContains;
  /**
   * 差异量 比较(notcontains)
   */
  private Long differenceQuantityNotcontains;
  /**
   * 差异量 比较(startswith)
   */
  private Long differenceQuantityStartswith;
  /**
   * 差异量 比较(endswith)
   */
  private Long differenceQuantityEndswith;
  /**
   * 差异量 比较(isnull)
   */
  private Boolean differenceQuantityIsnull;
  /**
   * 差异量 比较(isnotnull)
   */
  private Boolean differenceQuantityIsnotnull;

  /**
   * 运输方式
   */
  private String typeOfShipping;

  /**
   * 运输方式 比较(eq)
   */
  private String typeOfShippingEq;
  /**
   * 运输方式 比较(neq)
   */
  private String typeOfShippingNeq;
  /**
   * 运输方式 比较(gt)
   */
  private String typeOfShippingGt;
  /**
   * 运输方式 比较(gte)
   */
  private String typeOfShippingGte;
  /**
   * 运输方式 比较(lt)
   */
  private String typeOfShippingLt;
  /**
   * 运输方式 比较(lte)
   */
  private String typeOfShippingLte;
  /**
   * 运输方式 比较(contains)
   */
  private String typeOfShippingContains;
  /**
   * 运输方式 比较(notcontains)
   */
  private String typeOfShippingNotcontains;
  /**
   * 运输方式 比较(startswith)
   */
  private String typeOfShippingStartswith;
  /**
   * 运输方式 比较(endswith)
   */
  private String typeOfShippingEndswith;
  /**
   * 运输方式 比较(isnull)
   */
  private Boolean typeOfShippingIsnull;
  /**
   * 运输方式 比较(isnotnull)
   */
  private Boolean typeOfShippingIsnotnull;

  /**
   * 运输方式(精确搜索)
   */
  private List<String> typeOfShippingInList;

  /**
   * 物流商
   */
  private Long logisticsBusinessId;

  /**
   * 物流商 比较(eq)
   */
  private Long logisticsBusinessIdEq;
  /**
   * 物流商 比较(neq)
   */
  private Long logisticsBusinessIdNeq;
  /**
   * 物流商 比较(gt)
   */
  private Long logisticsBusinessIdGt;
  /**
   * 物流商 比较(gte)
   */
  private Long logisticsBusinessIdGte;
  /**
   * 物流商 比较(lt)
   */
  private Long logisticsBusinessIdLt;
  /**
   * 物流商 比较(lte)
   */
  private Long logisticsBusinessIdLte;
  /**
   * 物流商 比较(contains)
   */
  private Long logisticsBusinessIdContains;
  /**
   * 物流商 比较(notcontains)
   */
  private Long logisticsBusinessIdNotcontains;
  /**
   * 物流商 比较(startswith)
   */
  private Long logisticsBusinessIdStartswith;
  /**
   * 物流商 比较(endswith)
   */
  private Long logisticsBusinessIdEndswith;
  /**
   * 物流商 比较(isnull)
   */
  private Boolean logisticsBusinessIdIsnull;
  /**
   * 物流商 比较(isnotnull)
   */
  private Boolean logisticsBusinessIdIsnotnull;
  /**
   * 物流商的物流商 比较(eq)
   */
  private String logisticsBusinessIdNameEq;
  /**
   * 物流商的物流商 比较(neq)
   */
  private String logisticsBusinessIdNameNeq;
  /**
   * 物流商的物流商 比较(gt)
   */
  private String logisticsBusinessIdNameGt;
  /**
   * 物流商的物流商 比较(gte)
   */
  private String logisticsBusinessIdNameGte;
  /**
   * 物流商的物流商 比较(lt)
   */
  private String logisticsBusinessIdNameLt;
  /**
   * 物流商的物流商 比较(lte)
   */
  private String logisticsBusinessIdNameLte;
  /**
   * 物流商的物流商 比较(contains)
   */
  private String logisticsBusinessIdNameContains;
  /**
   * 物流商的物流商 比较(notcontains)
   */
  private String logisticsBusinessIdNameNotcontains;
  /**
   * 物流商的物流商 比较(startswith)
   */
  private String logisticsBusinessIdNameStartswith;
  /**
   * 物流商的物流商 比较(endswith)
   */
  private String logisticsBusinessIdNameEndswith;
  /**
   * 物流商的物流商 比较(isnull)
   */
  private Boolean logisticsBusinessIdNameIsnull;
  /**
   * 物流商的物流商 比较(isnotnull)
   */
  private Boolean logisticsBusinessIdNameIsnotnull;

  /**
   * 物流商(范围搜索)
   */
  private List<Long> logisticsBusinessIdInList;

  /**
   * 物流渠道
   */
  private Long logisticsChannel;

  /**
   * 物流渠道 比较(eq)
   */
  private Long logisticsChannelEq;
  /**
   * 物流渠道 比较(neq)
   */
  private Long logisticsChannelNeq;
  /**
   * 物流渠道 比较(gt)
   */
  private Long logisticsChannelGt;
  /**
   * 物流渠道 比较(gte)
   */
  private Long logisticsChannelGte;
  /**
   * 物流渠道 比较(lt)
   */
  private Long logisticsChannelLt;
  /**
   * 物流渠道 比较(lte)
   */
  private Long logisticsChannelLte;
  /**
   * 物流渠道 比较(contains)
   */
  private Long logisticsChannelContains;
  /**
   * 物流渠道 比较(notcontains)
   */
  private Long logisticsChannelNotcontains;
  /**
   * 物流渠道 比较(startswith)
   */
  private Long logisticsChannelStartswith;
  /**
   * 物流渠道 比较(endswith)
   */
  private Long logisticsChannelEndswith;
  /**
   * 物流渠道 比较(isnull)
   */
  private Boolean logisticsChannelIsnull;
  /**
   * 物流渠道 比较(isnotnull)
   */
  private Boolean logisticsChannelIsnotnull;
  /**
   * 物流渠道的物流渠道 比较(eq)
   */
  private String logisticsChannelNameEq;
  /**
   * 物流渠道的物流渠道 比较(neq)
   */
  private String logisticsChannelNameNeq;
  /**
   * 物流渠道的物流渠道 比较(gt)
   */
  private String logisticsChannelNameGt;
  /**
   * 物流渠道的物流渠道 比较(gte)
   */
  private String logisticsChannelNameGte;
  /**
   * 物流渠道的物流渠道 比较(lt)
   */
  private String logisticsChannelNameLt;
  /**
   * 物流渠道的物流渠道 比较(lte)
   */
  private String logisticsChannelNameLte;
  /**
   * 物流渠道的物流渠道 比较(contains)
   */
  private String logisticsChannelNameContains;
  /**
   * 物流渠道的物流渠道 比较(notcontains)
   */
  private String logisticsChannelNameNotcontains;
  /**
   * 物流渠道的物流渠道 比较(startswith)
   */
  private String logisticsChannelNameStartswith;
  /**
   * 物流渠道的物流渠道 比较(endswith)
   */
  private String logisticsChannelNameEndswith;
  /**
   * 物流渠道的物流渠道 比较(isnull)
   */
  private Boolean logisticsChannelNameIsnull;
  /**
   * 物流渠道的物流渠道 比较(isnotnull)
   */
  private Boolean logisticsChannelNameIsnotnull;

  /**
   * 物流渠道(范围搜索)
   */
  private List<Long> logisticsChannelInList;

  /**
   * 最早预计到货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date estimatedTimeOfArrivalStart;

  /**
   * 最晚预计到货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date estimatedTimeOfArrivalEnd;

  /**
   * 预计到货时间 比较(eq)
   */
  private Date estimatedTimeOfArrivalEq;
  /**
   * 预计到货时间 比较(neq)
   */
  private Date estimatedTimeOfArrivalNeq;
  /**
   * 预计到货时间 比较(gt)
   */
  private Date estimatedTimeOfArrivalGt;
  /**
   * 预计到货时间 比较(gte)
   */
  private Date estimatedTimeOfArrivalGte;
  /**
   * 预计到货时间 比较(lt)
   */
  private Date estimatedTimeOfArrivalLt;
  /**
   * 预计到货时间 比较(lte)
   */
  private Date estimatedTimeOfArrivalLte;
  /**
   * 预计到货时间 比较(contains)
   */
  private Date estimatedTimeOfArrivalContains;
  /**
   * 预计到货时间 比较(notcontains)
   */
  private Date estimatedTimeOfArrivalNotcontains;
  /**
   * 预计到货时间 比较(startswith)
   */
  private Date estimatedTimeOfArrivalStartswith;
  /**
   * 预计到货时间 比较(endswith)
   */
  private Date estimatedTimeOfArrivalEndswith;
  /**
   * 预计到货时间 比较(isnull)
   */
  private Boolean estimatedTimeOfArrivalIsnull;
  /**
   * 预计到货时间 比较(isnotnull)
   */
  private Boolean estimatedTimeOfArrivalIsnotnull;

  /**
   * 发货仓库
   */
  private Long deliveryWarehouseId;

  /**
   * 发货仓库 比较(eq)
   */
  private Long deliveryWarehouseIdEq;
  /**
   * 发货仓库 比较(neq)
   */
  private Long deliveryWarehouseIdNeq;
  /**
   * 发货仓库 比较(gt)
   */
  private Long deliveryWarehouseIdGt;
  /**
   * 发货仓库 比较(gte)
   */
  private Long deliveryWarehouseIdGte;
  /**
   * 发货仓库 比较(lt)
   */
  private Long deliveryWarehouseIdLt;
  /**
   * 发货仓库 比较(lte)
   */
  private Long deliveryWarehouseIdLte;
  /**
   * 发货仓库 比较(contains)
   */
  private Long deliveryWarehouseIdContains;
  /**
   * 发货仓库 比较(notcontains)
   */
  private Long deliveryWarehouseIdNotcontains;
  /**
   * 发货仓库 比较(startswith)
   */
  private Long deliveryWarehouseIdStartswith;
  /**
   * 发货仓库 比较(endswith)
   */
  private Long deliveryWarehouseIdEndswith;
  /**
   * 发货仓库 比较(isnull)
   */
  private Boolean deliveryWarehouseIdIsnull;
  /**
   * 发货仓库 比较(isnotnull)
   */
  private Boolean deliveryWarehouseIdIsnotnull;
  /**
   * 发货仓库的仓库名称 比较(eq)
   */
  private String deliveryWarehouseIdNameEq;
  /**
   * 发货仓库的仓库名称 比较(neq)
   */
  private String deliveryWarehouseIdNameNeq;
  /**
   * 发货仓库的仓库名称 比较(gt)
   */
  private String deliveryWarehouseIdNameGt;
  /**
   * 发货仓库的仓库名称 比较(gte)
   */
  private String deliveryWarehouseIdNameGte;
  /**
   * 发货仓库的仓库名称 比较(lt)
   */
  private String deliveryWarehouseIdNameLt;
  /**
   * 发货仓库的仓库名称 比较(lte)
   */
  private String deliveryWarehouseIdNameLte;
  /**
   * 发货仓库的仓库名称 比较(contains)
   */
  private String deliveryWarehouseIdNameContains;
  /**
   * 发货仓库的仓库名称 比较(notcontains)
   */
  private String deliveryWarehouseIdNameNotcontains;
  /**
   * 发货仓库的仓库名称 比较(startswith)
   */
  private String deliveryWarehouseIdNameStartswith;
  /**
   * 发货仓库的仓库名称 比较(endswith)
   */
  private String deliveryWarehouseIdNameEndswith;
  /**
   * 发货仓库的仓库名称 比较(isnull)
   */
  private Boolean deliveryWarehouseIdNameIsnull;
  /**
   * 发货仓库的仓库名称 比较(isnotnull)
   */
  private Boolean deliveryWarehouseIdNameIsnotnull;

  /**
   * 发货仓库(范围搜索)
   */
  private List<Long> deliveryWarehouseIdInList;

  /**
   * 包装类型
   */
  private String packagingType;

  /**
   * 包装类型 比较(eq)
   */
  private String packagingTypeEq;
  /**
   * 包装类型 比较(neq)
   */
  private String packagingTypeNeq;
  /**
   * 包装类型 比较(gt)
   */
  private String packagingTypeGt;
  /**
   * 包装类型 比较(gte)
   */
  private String packagingTypeGte;
  /**
   * 包装类型 比较(lt)
   */
  private String packagingTypeLt;
  /**
   * 包装类型 比较(lte)
   */
  private String packagingTypeLte;
  /**
   * 包装类型 比较(contains)
   */
  private String packagingTypeContains;
  /**
   * 包装类型 比较(notcontains)
   */
  private String packagingTypeNotcontains;
  /**
   * 包装类型 比较(startswith)
   */
  private String packagingTypeStartswith;
  /**
   * 包装类型 比较(endswith)
   */
  private String packagingTypeEndswith;
  /**
   * 包装类型 比较(isnull)
   */
  private Boolean packagingTypeIsnull;
  /**
   * 包装类型 比较(isnotnull)
   */
  private Boolean packagingTypeIsnotnull;

  /**
   * 包装类型(精确搜索)
   */
  private List<String> packagingTypeInList;

  /**
   * 备注(模糊搜索)
   */
  private String remarks;

  /**
   * 备注 比较(eq)
   */
  private String remarksEq;
  /**
   * 备注 比较(neq)
   */
  private String remarksNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarksGt;
  /**
   * 备注 比较(gte)
   */
  private String remarksGte;
  /**
   * 备注 比较(lt)
   */
  private String remarksLt;
  /**
   * 备注 比较(lte)
   */
  private String remarksLte;
  /**
   * 备注 比较(contains)
   */
  private String remarksContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarksNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarksStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarksEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarksIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarksIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarksInList;

  /**
   * 状态
   */
  private String state;

  /**
   * 状态 比较(eq)
   */
  private String stateEq;
  /**
   * 状态 比较(neq)
   */
  private String stateNeq;
  /**
   * 状态 比较(gt)
   */
  private String stateGt;
  /**
   * 状态 比较(gte)
   */
  private String stateGte;
  /**
   * 状态 比较(lt)
   */
  private String stateLt;
  /**
   * 状态 比较(lte)
   */
  private String stateLte;
  /**
   * 状态 比较(contains)
   */
  private String stateContains;
  /**
   * 状态 比较(notcontains)
   */
  private String stateNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String stateStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String stateEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean stateIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean stateIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> stateInList;

  /**
   * 物流预计时效(模糊搜索)
   */
  private String estimatedTimeOfLogistics;

  /**
   * 物流预计时效 比较(eq)
   */
  private String estimatedTimeOfLogisticsEq;
  /**
   * 物流预计时效 比较(neq)
   */
  private String estimatedTimeOfLogisticsNeq;
  /**
   * 物流预计时效 比较(gt)
   */
  private String estimatedTimeOfLogisticsGt;
  /**
   * 物流预计时效 比较(gte)
   */
  private String estimatedTimeOfLogisticsGte;
  /**
   * 物流预计时效 比较(lt)
   */
  private String estimatedTimeOfLogisticsLt;
  /**
   * 物流预计时效 比较(lte)
   */
  private String estimatedTimeOfLogisticsLte;
  /**
   * 物流预计时效 比较(contains)
   */
  private String estimatedTimeOfLogisticsContains;
  /**
   * 物流预计时效 比较(notcontains)
   */
  private String estimatedTimeOfLogisticsNotcontains;
  /**
   * 物流预计时效 比较(startswith)
   */
  private String estimatedTimeOfLogisticsStartswith;
  /**
   * 物流预计时效 比较(endswith)
   */
  private String estimatedTimeOfLogisticsEndswith;
  /**
   * 物流预计时效 比较(isnull)
   */
  private Boolean estimatedTimeOfLogisticsIsnull;
  /**
   * 物流预计时效 比较(isnotnull)
   */
  private Boolean estimatedTimeOfLogisticsIsnotnull;

  /**
   * 物流预计时效(精确搜索)
   */
  private List<String> estimatedTimeOfLogisticsInList;

  /**
   * 箱规名称(模糊搜索)
   */
  private String boxName;

  /**
   * 箱规名称 比较(eq)
   */
  private String boxNameEq;
  /**
   * 箱规名称 比较(neq)
   */
  private String boxNameNeq;
  /**
   * 箱规名称 比较(gt)
   */
  private String boxNameGt;
  /**
   * 箱规名称 比较(gte)
   */
  private String boxNameGte;
  /**
   * 箱规名称 比较(lt)
   */
  private String boxNameLt;
  /**
   * 箱规名称 比较(lte)
   */
  private String boxNameLte;
  /**
   * 箱规名称 比较(contains)
   */
  private String boxNameContains;
  /**
   * 箱规名称 比较(notcontains)
   */
  private String boxNameNotcontains;
  /**
   * 箱规名称 比较(startswith)
   */
  private String boxNameStartswith;
  /**
   * 箱规名称 比较(endswith)
   */
  private String boxNameEndswith;
  /**
   * 箱规名称 比较(isnull)
   */
  private Boolean boxNameIsnull;
  /**
   * 箱规名称 比较(isnotnull)
   */
  private Boolean boxNameIsnotnull;

  /**
   * 箱规名称(精确搜索)
   */
  private List<String> boxNameInList;

  /**
   * 单箱数量（PCS）
   */
  private Integer perCarton;

  /**
   * 最小单箱数量（PCS）
   */
  private Integer perCartonMin;

  /**
   * 最大单箱数量（PCS）
   */
  private Integer perCartonMax;

  /**
   * 单箱数量（PCS） 比较(eq)
   */
  private Integer perCartonEq;
  /**
   * 单箱数量（PCS） 比较(neq)
   */
  private Integer perCartonNeq;
  /**
   * 单箱数量（PCS） 比较(gt)
   */
  private Integer perCartonGt;
  /**
   * 单箱数量（PCS） 比较(gte)
   */
  private Integer perCartonGte;
  /**
   * 单箱数量（PCS） 比较(lt)
   */
  private Integer perCartonLt;
  /**
   * 单箱数量（PCS） 比较(lte)
   */
  private Integer perCartonLte;
  /**
   * 单箱数量（PCS） 比较(contains)
   */
  private Integer perCartonContains;
  /**
   * 单箱数量（PCS） 比较(notcontains)
   */
  private Integer perCartonNotcontains;
  /**
   * 单箱数量（PCS） 比较(startswith)
   */
  private Integer perCartonStartswith;
  /**
   * 单箱数量（PCS） 比较(endswith)
   */
  private Integer perCartonEndswith;
  /**
   * 单箱数量（PCS） 比较(isnull)
   */
  private Boolean perCartonIsnull;
  /**
   * 单箱数量（PCS） 比较(isnotnull)
   */
  private Boolean perCartonIsnotnull;

  /**
   * 箱数
   */
  private Integer cartonNumbers;

  /**
   * 最小箱数
   */
  private Integer cartonNumbersMin;

  /**
   * 最大箱数
   */
  private Integer cartonNumbersMax;

  /**
   * 箱数 比较(eq)
   */
  private Integer cartonNumbersEq;
  /**
   * 箱数 比较(neq)
   */
  private Integer cartonNumbersNeq;
  /**
   * 箱数 比较(gt)
   */
  private Integer cartonNumbersGt;
  /**
   * 箱数 比较(gte)
   */
  private Integer cartonNumbersGte;
  /**
   * 箱数 比较(lt)
   */
  private Integer cartonNumbersLt;
  /**
   * 箱数 比较(lte)
   */
  private Integer cartonNumbersLte;
  /**
   * 箱数 比较(contains)
   */
  private Integer cartonNumbersContains;
  /**
   * 箱数 比较(notcontains)
   */
  private Integer cartonNumbersNotcontains;
  /**
   * 箱数 比较(startswith)
   */
  private Integer cartonNumbersStartswith;
  /**
   * 箱数 比较(endswith)
   */
  private Integer cartonNumbersEndswith;
  /**
   * 箱数 比较(isnull)
   */
  private Boolean cartonNumbersIsnull;
  /**
   * 箱数 比较(isnotnull)
   */
  private Boolean cartonNumbersIsnotnull;

  /**
   * 最早发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date scheduledDeliveryTimeStart;

  /**
   * 最晚发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date scheduledDeliveryTimeEnd;

  /**
   * 发货时间 比较(eq)
   */
  private Date scheduledDeliveryTimeEq;
  /**
   * 发货时间 比较(neq)
   */
  private Date scheduledDeliveryTimeNeq;
  /**
   * 发货时间 比较(gt)
   */
  private Date scheduledDeliveryTimeGt;
  /**
   * 发货时间 比较(gte)
   */
  private Date scheduledDeliveryTimeGte;
  /**
   * 发货时间 比较(lt)
   */
  private Date scheduledDeliveryTimeLt;
  /**
   * 发货时间 比较(lte)
   */
  private Date scheduledDeliveryTimeLte;
  /**
   * 发货时间 比较(contains)
   */
  private Date scheduledDeliveryTimeContains;
  /**
   * 发货时间 比较(notcontains)
   */
  private Date scheduledDeliveryTimeNotcontains;
  /**
   * 发货时间 比较(startswith)
   */
  private Date scheduledDeliveryTimeStartswith;
  /**
   * 发货时间 比较(endswith)
   */
  private Date scheduledDeliveryTimeEndswith;
  /**
   * 发货时间 比较(isnull)
   */
  private Boolean scheduledDeliveryTimeIsnull;
  /**
   * 发货时间 比较(isnotnull)
   */
  private Boolean scheduledDeliveryTimeIsnotnull;

  /**
   * 发货仓库店铺
   */
  private Long deliveryWarehouseStoreId;

  /**
   * 发货仓库店铺 比较(eq)
   */
  private Long deliveryWarehouseStoreIdEq;
  /**
   * 发货仓库店铺 比较(neq)
   */
  private Long deliveryWarehouseStoreIdNeq;
  /**
   * 发货仓库店铺 比较(gt)
   */
  private Long deliveryWarehouseStoreIdGt;
  /**
   * 发货仓库店铺 比较(gte)
   */
  private Long deliveryWarehouseStoreIdGte;
  /**
   * 发货仓库店铺 比较(lt)
   */
  private Long deliveryWarehouseStoreIdLt;
  /**
   * 发货仓库店铺 比较(lte)
   */
  private Long deliveryWarehouseStoreIdLte;
  /**
   * 发货仓库店铺 比较(contains)
   */
  private Long deliveryWarehouseStoreIdContains;
  /**
   * 发货仓库店铺 比较(notcontains)
   */
  private Long deliveryWarehouseStoreIdNotcontains;
  /**
   * 发货仓库店铺 比较(startswith)
   */
  private Long deliveryWarehouseStoreIdStartswith;
  /**
   * 发货仓库店铺 比较(endswith)
   */
  private Long deliveryWarehouseStoreIdEndswith;
  /**
   * 发货仓库店铺 比较(isnull)
   */
  private Boolean deliveryWarehouseStoreIdIsnull;
  /**
   * 发货仓库店铺 比较(isnotnull)
   */
  private Boolean deliveryWarehouseStoreIdIsnotnull;
  /**
   * 发货仓库店铺的名称 比较(eq)
   */
  private String deliveryWarehouseStoreIdShopNameEq;
  /**
   * 发货仓库店铺的名称 比较(neq)
   */
  private String deliveryWarehouseStoreIdShopNameNeq;
  /**
   * 发货仓库店铺的名称 比较(gt)
   */
  private String deliveryWarehouseStoreIdShopNameGt;
  /**
   * 发货仓库店铺的名称 比较(gte)
   */
  private String deliveryWarehouseStoreIdShopNameGte;
  /**
   * 发货仓库店铺的名称 比较(lt)
   */
  private String deliveryWarehouseStoreIdShopNameLt;
  /**
   * 发货仓库店铺的名称 比较(lte)
   */
  private String deliveryWarehouseStoreIdShopNameLte;
  /**
   * 发货仓库店铺的名称 比较(contains)
   */
  private String deliveryWarehouseStoreIdShopNameContains;
  /**
   * 发货仓库店铺的名称 比较(notcontains)
   */
  private String deliveryWarehouseStoreIdShopNameNotcontains;
  /**
   * 发货仓库店铺的名称 比较(startswith)
   */
  private String deliveryWarehouseStoreIdShopNameStartswith;
  /**
   * 发货仓库店铺的名称 比较(endswith)
   */
  private String deliveryWarehouseStoreIdShopNameEndswith;
  /**
   * 发货仓库店铺的名称 比较(isnull)
   */
  private Boolean deliveryWarehouseStoreIdShopNameIsnull;
  /**
   * 发货仓库店铺的名称 比较(isnotnull)
   */
  private Boolean deliveryWarehouseStoreIdShopNameIsnotnull;

  /**
   * 发货仓库店铺(范围搜索)
   */
  private List<Long> deliveryWarehouseStoreIdInList;

  /**
   * 发货仓库FNSKU
   */
  private Long deliveryWarehouseStoreFnsku;

  /**
   * 发货仓库FNSKU 比较(eq)
   */
  private Long deliveryWarehouseStoreFnskuEq;
  /**
   * 发货仓库FNSKU 比较(neq)
   */
  private Long deliveryWarehouseStoreFnskuNeq;
  /**
   * 发货仓库FNSKU 比较(gt)
   */
  private Long deliveryWarehouseStoreFnskuGt;
  /**
   * 发货仓库FNSKU 比较(gte)
   */
  private Long deliveryWarehouseStoreFnskuGte;
  /**
   * 发货仓库FNSKU 比较(lt)
   */
  private Long deliveryWarehouseStoreFnskuLt;
  /**
   * 发货仓库FNSKU 比较(lte)
   */
  private Long deliveryWarehouseStoreFnskuLte;
  /**
   * 发货仓库FNSKU 比较(contains)
   */
  private Long deliveryWarehouseStoreFnskuContains;
  /**
   * 发货仓库FNSKU 比较(notcontains)
   */
  private Long deliveryWarehouseStoreFnskuNotcontains;
  /**
   * 发货仓库FNSKU 比较(startswith)
   */
  private Long deliveryWarehouseStoreFnskuStartswith;
  /**
   * 发货仓库FNSKU 比较(endswith)
   */
  private Long deliveryWarehouseStoreFnskuEndswith;
  /**
   * 发货仓库FNSKU 比较(isnull)
   */
  private Boolean deliveryWarehouseStoreFnskuIsnull;
  /**
   * 发货仓库FNSKU 比较(isnotnull)
   */
  private Boolean deliveryWarehouseStoreFnskuIsnotnull;
  /**
   * 发货仓库FNSKU的FNSKU 比较(eq)
   */
  private String deliveryWarehouseStoreFnskuFnskuEq;
  /**
   * 发货仓库FNSKU的FNSKU 比较(neq)
   */
  private String deliveryWarehouseStoreFnskuFnskuNeq;
  /**
   * 发货仓库FNSKU的FNSKU 比较(gt)
   */
  private String deliveryWarehouseStoreFnskuFnskuGt;
  /**
   * 发货仓库FNSKU的FNSKU 比较(gte)
   */
  private String deliveryWarehouseStoreFnskuFnskuGte;
  /**
   * 发货仓库FNSKU的FNSKU 比较(lt)
   */
  private String deliveryWarehouseStoreFnskuFnskuLt;
  /**
   * 发货仓库FNSKU的FNSKU 比较(lte)
   */
  private String deliveryWarehouseStoreFnskuFnskuLte;
  /**
   * 发货仓库FNSKU的FNSKU 比较(contains)
   */
  private String deliveryWarehouseStoreFnskuFnskuContains;
  /**
   * 发货仓库FNSKU的FNSKU 比较(notcontains)
   */
  private String deliveryWarehouseStoreFnskuFnskuNotcontains;
  /**
   * 发货仓库FNSKU的FNSKU 比较(startswith)
   */
  private String deliveryWarehouseStoreFnskuFnskuStartswith;
  /**
   * 发货仓库FNSKU的FNSKU 比较(endswith)
   */
  private String deliveryWarehouseStoreFnskuFnskuEndswith;
  /**
   * 发货仓库FNSKU的FNSKU 比较(isnull)
   */
  private Boolean deliveryWarehouseStoreFnskuFnskuIsnull;
  /**
   * 发货仓库FNSKU的FNSKU 比较(isnotnull)
   */
  private Boolean deliveryWarehouseStoreFnskuFnskuIsnotnull;

  /**
   * 发货仓库FNSKU(范围搜索)
   */
  private List<Long> deliveryWarehouseStoreFnskuInList;

  /**
   * 锁定仓位
   */
  private Long lockBin;

  /**
   * 锁定仓位 比较(eq)
   */
  private Long lockBinEq;
  /**
   * 锁定仓位 比较(neq)
   */
  private Long lockBinNeq;
  /**
   * 锁定仓位 比较(gt)
   */
  private Long lockBinGt;
  /**
   * 锁定仓位 比较(gte)
   */
  private Long lockBinGte;
  /**
   * 锁定仓位 比较(lt)
   */
  private Long lockBinLt;
  /**
   * 锁定仓位 比较(lte)
   */
  private Long lockBinLte;
  /**
   * 锁定仓位 比较(contains)
   */
  private Long lockBinContains;
  /**
   * 锁定仓位 比较(notcontains)
   */
  private Long lockBinNotcontains;
  /**
   * 锁定仓位 比较(startswith)
   */
  private Long lockBinStartswith;
  /**
   * 锁定仓位 比较(endswith)
   */
  private Long lockBinEndswith;
  /**
   * 锁定仓位 比较(isnull)
   */
  private Boolean lockBinIsnull;
  /**
   * 锁定仓位 比较(isnotnull)
   */
  private Boolean lockBinIsnotnull;
  /**
   * 锁定仓位的仓位 比较(eq)
   */
  private String lockBinStorageBinEq;
  /**
   * 锁定仓位的仓位 比较(neq)
   */
  private String lockBinStorageBinNeq;
  /**
   * 锁定仓位的仓位 比较(gt)
   */
  private String lockBinStorageBinGt;
  /**
   * 锁定仓位的仓位 比较(gte)
   */
  private String lockBinStorageBinGte;
  /**
   * 锁定仓位的仓位 比较(lt)
   */
  private String lockBinStorageBinLt;
  /**
   * 锁定仓位的仓位 比较(lte)
   */
  private String lockBinStorageBinLte;
  /**
   * 锁定仓位的仓位 比较(contains)
   */
  private String lockBinStorageBinContains;
  /**
   * 锁定仓位的仓位 比较(notcontains)
   */
  private String lockBinStorageBinNotcontains;
  /**
   * 锁定仓位的仓位 比较(startswith)
   */
  private String lockBinStorageBinStartswith;
  /**
   * 锁定仓位的仓位 比较(endswith)
   */
  private String lockBinStorageBinEndswith;
  /**
   * 锁定仓位的仓位 比较(isnull)
   */
  private Boolean lockBinStorageBinIsnull;
  /**
   * 锁定仓位的仓位 比较(isnotnull)
   */
  private Boolean lockBinStorageBinIsnotnull;

  /**
   * 锁定仓位(范围搜索)
   */
  private List<Long> lockBinInList;

  /**
   * FBA库存预测
   */
  private Integer fbaForecastingInventoryTechnique;

  /**
   * 最小FBA库存预测
   */
  private Integer fbaForecastingInventoryTechniqueMin;

  /**
   * 最大FBA库存预测
   */
  private Integer fbaForecastingInventoryTechniqueMax;

  /**
   * FBA库存预测 比较(eq)
   */
  private Integer fbaForecastingInventoryTechniqueEq;
  /**
   * FBA库存预测 比较(neq)
   */
  private Integer fbaForecastingInventoryTechniqueNeq;
  /**
   * FBA库存预测 比较(gt)
   */
  private Integer fbaForecastingInventoryTechniqueGt;
  /**
   * FBA库存预测 比较(gte)
   */
  private Integer fbaForecastingInventoryTechniqueGte;
  /**
   * FBA库存预测 比较(lt)
   */
  private Integer fbaForecastingInventoryTechniqueLt;
  /**
   * FBA库存预测 比较(lte)
   */
  private Integer fbaForecastingInventoryTechniqueLte;
  /**
   * FBA库存预测 比较(contains)
   */
  private Integer fbaForecastingInventoryTechniqueContains;
  /**
   * FBA库存预测 比较(notcontains)
   */
  private Integer fbaForecastingInventoryTechniqueNotcontains;
  /**
   * FBA库存预测 比较(startswith)
   */
  private Integer fbaForecastingInventoryTechniqueStartswith;
  /**
   * FBA库存预测 比较(endswith)
   */
  private Integer fbaForecastingInventoryTechniqueEndswith;
  /**
   * FBA库存预测 比较(isnull)
   */
  private Boolean fbaForecastingInventoryTechniqueIsnull;
  /**
   * FBA库存预测 比较(isnotnull)
   */
  private Boolean fbaForecastingInventoryTechniqueIsnotnull;

  /**
   * 可用量
   */
  private Integer quantityAvailable;

  /**
   * 最小可用量
   */
  private Integer quantityAvailableMin;

  /**
   * 最大可用量
   */
  private Integer quantityAvailableMax;

  /**
   * 可用量 比较(eq)
   */
  private Integer quantityAvailableEq;
  /**
   * 可用量 比较(neq)
   */
  private Integer quantityAvailableNeq;
  /**
   * 可用量 比较(gt)
   */
  private Integer quantityAvailableGt;
  /**
   * 可用量 比较(gte)
   */
  private Integer quantityAvailableGte;
  /**
   * 可用量 比较(lt)
   */
  private Integer quantityAvailableLt;
  /**
   * 可用量 比较(lte)
   */
  private Integer quantityAvailableLte;
  /**
   * 可用量 比较(contains)
   */
  private Integer quantityAvailableContains;
  /**
   * 可用量 比较(notcontains)
   */
  private Integer quantityAvailableNotcontains;
  /**
   * 可用量 比较(startswith)
   */
  private Integer quantityAvailableStartswith;
  /**
   * 可用量 比较(endswith)
   */
  private Integer quantityAvailableEndswith;
  /**
   * 可用量 比较(isnull)
   */
  private Boolean quantityAvailableIsnull;
  /**
   * 可用量 比较(isnotnull)
   */
  private Boolean quantityAvailableIsnotnull;

  /**
   * 待检待上架量
   */
  private Integer quantityTest;

  /**
   * 最小待检待上架量
   */
  private Integer quantityTestMin;

  /**
   * 最大待检待上架量
   */
  private Integer quantityTestMax;

  /**
   * 待检待上架量 比较(eq)
   */
  private Integer quantityTestEq;
  /**
   * 待检待上架量 比较(neq)
   */
  private Integer quantityTestNeq;
  /**
   * 待检待上架量 比较(gt)
   */
  private Integer quantityTestGt;
  /**
   * 待检待上架量 比较(gte)
   */
  private Integer quantityTestGte;
  /**
   * 待检待上架量 比较(lt)
   */
  private Integer quantityTestLt;
  /**
   * 待检待上架量 比较(lte)
   */
  private Integer quantityTestLte;
  /**
   * 待检待上架量 比较(contains)
   */
  private Integer quantityTestContains;
  /**
   * 待检待上架量 比较(notcontains)
   */
  private Integer quantityTestNotcontains;
  /**
   * 待检待上架量 比较(startswith)
   */
  private Integer quantityTestStartswith;
  /**
   * 待检待上架量 比较(endswith)
   */
  private Integer quantityTestEndswith;
  /**
   * 待检待上架量 比较(isnull)
   */
  private Boolean quantityTestIsnull;
  /**
   * 待检待上架量 比较(isnotnull)
   */
  private Boolean quantityTestIsnotnull;

  /**
   * 待到货量
   */
  private Integer quantityAog;

  /**
   * 最小待到货量
   */
  private Integer quantityAogMin;

  /**
   * 最大待到货量
   */
  private Integer quantityAogMax;

  /**
   * 待到货量 比较(eq)
   */
  private Integer quantityAogEq;
  /**
   * 待到货量 比较(neq)
   */
  private Integer quantityAogNeq;
  /**
   * 待到货量 比较(gt)
   */
  private Integer quantityAogGt;
  /**
   * 待到货量 比较(gte)
   */
  private Integer quantityAogGte;
  /**
   * 待到货量 比较(lt)
   */
  private Integer quantityAogLt;
  /**
   * 待到货量 比较(lte)
   */
  private Integer quantityAogLte;
  /**
   * 待到货量 比较(contains)
   */
  private Integer quantityAogContains;
  /**
   * 待到货量 比较(notcontains)
   */
  private Integer quantityAogNotcontains;
  /**
   * 待到货量 比较(startswith)
   */
  private Integer quantityAogStartswith;
  /**
   * 待到货量 比较(endswith)
   */
  private Integer quantityAogEndswith;
  /**
   * 待到货量 比较(isnull)
   */
  private Boolean quantityAogIsnull;
  /**
   * 待到货量 比较(isnotnull)
   */
  private Boolean quantityAogIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 是否锁定库存
   */
  private Boolean isLock;

  /**
   * 是否锁定库存
   */
  private String isLockEq;

  /**
   * 是否加急
   */
  private Boolean isUrgent;

  /**
   * 是否加急
   */
  private String isUrgentEq;

  /**
   * 货件号(模糊搜索)
   */
  private String shipmentOrder;

  /**
   * 货件号 比较(eq)
   */
  private String shipmentOrderEq;
  /**
   * 货件号 比较(neq)
   */
  private String shipmentOrderNeq;
  /**
   * 货件号 比较(gt)
   */
  private String shipmentOrderGt;
  /**
   * 货件号 比较(gte)
   */
  private String shipmentOrderGte;
  /**
   * 货件号 比较(lt)
   */
  private String shipmentOrderLt;
  /**
   * 货件号 比较(lte)
   */
  private String shipmentOrderLte;
  /**
   * 货件号 比较(contains)
   */
  private String shipmentOrderContains;
  /**
   * 货件号 比较(notcontains)
   */
  private String shipmentOrderNotcontains;
  /**
   * 货件号 比较(startswith)
   */
  private String shipmentOrderStartswith;
  /**
   * 货件号 比较(endswith)
   */
  private String shipmentOrderEndswith;
  /**
   * 货件号 比较(isnull)
   */
  private Boolean shipmentOrderIsnull;
  /**
   * 货件号 比较(isnotnull)
   */
  private Boolean shipmentOrderIsnotnull;

  /**
   * 货件号(精确搜索)
   */
  private List<String> shipmentOrderInList;

  /**
   * 申报量
   */
  private Integer shipmentNum;

  /**
   * 最小申报量
   */
  private Integer shipmentNumMin;

  /**
   * 最大申报量
   */
  private Integer shipmentNumMax;

  /**
   * 申报量 比较(eq)
   */
  private Integer shipmentNumEq;
  /**
   * 申报量 比较(neq)
   */
  private Integer shipmentNumNeq;
  /**
   * 申报量 比较(gt)
   */
  private Integer shipmentNumGt;
  /**
   * 申报量 比较(gte)
   */
  private Integer shipmentNumGte;
  /**
   * 申报量 比较(lt)
   */
  private Integer shipmentNumLt;
  /**
   * 申报量 比较(lte)
   */
  private Integer shipmentNumLte;
  /**
   * 申报量 比较(contains)
   */
  private Integer shipmentNumContains;
  /**
   * 申报量 比较(notcontains)
   */
  private Integer shipmentNumNotcontains;
  /**
   * 申报量 比较(startswith)
   */
  private Integer shipmentNumStartswith;
  /**
   * 申报量 比较(endswith)
   */
  private Integer shipmentNumEndswith;
  /**
   * 申报量 比较(isnull)
   */
  private Boolean shipmentNumIsnull;
  /**
   * 申报量 比较(isnotnull)
   */
  private Boolean shipmentNumIsnotnull;

  /**
   * 发货单号(模糊搜索)
   */
  private String deliveryOrder;

  /**
   * 发货单号 比较(eq)
   */
  private String deliveryOrderEq;
  /**
   * 发货单号 比较(neq)
   */
  private String deliveryOrderNeq;
  /**
   * 发货单号 比较(gt)
   */
  private String deliveryOrderGt;
  /**
   * 发货单号 比较(gte)
   */
  private String deliveryOrderGte;
  /**
   * 发货单号 比较(lt)
   */
  private String deliveryOrderLt;
  /**
   * 发货单号 比较(lte)
   */
  private String deliveryOrderLte;
  /**
   * 发货单号 比较(contains)
   */
  private String deliveryOrderContains;
  /**
   * 发货单号 比较(notcontains)
   */
  private String deliveryOrderNotcontains;
  /**
   * 发货单号 比较(startswith)
   */
  private String deliveryOrderStartswith;
  /**
   * 发货单号 比较(endswith)
   */
  private String deliveryOrderEndswith;
  /**
   * 发货单号 比较(isnull)
   */
  private Boolean deliveryOrderIsnull;
  /**
   * 发货单号 比较(isnotnull)
   */
  private Boolean deliveryOrderIsnotnull;

  /**
   * 发货单号(精确搜索)
   */
  private List<String> deliveryOrderInList;

  /**
   * 关联量
   */
  private Integer deliverNum;

  /**
   * 最小关联量
   */
  private Integer deliverNumMin;

  /**
   * 最大关联量
   */
  private Integer deliverNumMax;

  /**
   * 关联量 比较(eq)
   */
  private Integer deliverNumEq;
  /**
   * 关联量 比较(neq)
   */
  private Integer deliverNumNeq;
  /**
   * 关联量 比较(gt)
   */
  private Integer deliverNumGt;
  /**
   * 关联量 比较(gte)
   */
  private Integer deliverNumGte;
  /**
   * 关联量 比较(lt)
   */
  private Integer deliverNumLt;
  /**
   * 关联量 比较(lte)
   */
  private Integer deliverNumLte;
  /**
   * 关联量 比较(contains)
   */
  private Integer deliverNumContains;
  /**
   * 关联量 比较(notcontains)
   */
  private Integer deliverNumNotcontains;
  /**
   * 关联量 比较(startswith)
   */
  private Integer deliverNumStartswith;
  /**
   * 关联量 比较(endswith)
   */
  private Integer deliverNumEndswith;
  /**
   * 关联量 比较(isnull)
   */
  private Boolean deliverNumIsnull;
  /**
   * 关联量 比较(isnotnull)
   */
  private Boolean deliverNumIsnotnull;

  /**
   * 钩稽字段
   */
  private Integer planNumHidden;

  /**
   * 最小钩稽字段
   */
  private Integer planNumHiddenMin;

  /**
   * 最大钩稽字段
   */
  private Integer planNumHiddenMax;

  /**
   * 钩稽字段 比较(eq)
   */
  private Integer planNumHiddenEq;
  /**
   * 钩稽字段 比较(neq)
   */
  private Integer planNumHiddenNeq;
  /**
   * 钩稽字段 比较(gt)
   */
  private Integer planNumHiddenGt;
  /**
   * 钩稽字段 比较(gte)
   */
  private Integer planNumHiddenGte;
  /**
   * 钩稽字段 比较(lt)
   */
  private Integer planNumHiddenLt;
  /**
   * 钩稽字段 比较(lte)
   */
  private Integer planNumHiddenLte;
  /**
   * 钩稽字段 比较(contains)
   */
  private Integer planNumHiddenContains;
  /**
   * 钩稽字段 比较(notcontains)
   */
  private Integer planNumHiddenNotcontains;
  /**
   * 钩稽字段 比较(startswith)
   */
  private Integer planNumHiddenStartswith;
  /**
   * 钩稽字段 比较(endswith)
   */
  private Integer planNumHiddenEndswith;
  /**
   * 钩稽字段 比较(isnull)
   */
  private Boolean planNumHiddenIsnull;
  /**
   * 钩稽字段 比较(isnotnull)
   */
  private Boolean planNumHiddenIsnotnull;

  /**
   * 包装规格(模糊搜索)
   */
  private String specifications;

  /**
   * 包装规格 比较(eq)
   */
  private String specificationsEq;
  /**
   * 包装规格 比较(neq)
   */
  private String specificationsNeq;
  /**
   * 包装规格 比较(gt)
   */
  private String specificationsGt;
  /**
   * 包装规格 比较(gte)
   */
  private String specificationsGte;
  /**
   * 包装规格 比较(lt)
   */
  private String specificationsLt;
  /**
   * 包装规格 比较(lte)
   */
  private String specificationsLte;
  /**
   * 包装规格 比较(contains)
   */
  private String specificationsContains;
  /**
   * 包装规格 比较(notcontains)
   */
  private String specificationsNotcontains;
  /**
   * 包装规格 比较(startswith)
   */
  private String specificationsStartswith;
  /**
   * 包装规格 比较(endswith)
   */
  private String specificationsEndswith;
  /**
   * 包装规格 比较(isnull)
   */
  private Boolean specificationsIsnull;
  /**
   * 包装规格 比较(isnotnull)
   */
  private Boolean specificationsIsnotnull;

  /**
   * 包装规格(精确搜索)
   */
  private List<String> specificationsInList;

  /**
   * 箱规(模糊搜索)
   */
  private String boxgauge;

  /**
   * 箱规 比较(eq)
   */
  private String boxgaugeEq;
  /**
   * 箱规 比较(neq)
   */
  private String boxgaugeNeq;
  /**
   * 箱规 比较(gt)
   */
  private String boxgaugeGt;
  /**
   * 箱规 比较(gte)
   */
  private String boxgaugeGte;
  /**
   * 箱规 比较(lt)
   */
  private String boxgaugeLt;
  /**
   * 箱规 比较(lte)
   */
  private String boxgaugeLte;
  /**
   * 箱规 比较(contains)
   */
  private String boxgaugeContains;
  /**
   * 箱规 比较(notcontains)
   */
  private String boxgaugeNotcontains;
  /**
   * 箱规 比较(startswith)
   */
  private String boxgaugeStartswith;
  /**
   * 箱规 比较(endswith)
   */
  private String boxgaugeEndswith;
  /**
   * 箱规 比较(isnull)
   */
  private Boolean boxgaugeIsnull;
  /**
   * 箱规 比较(isnotnull)
   */
  private Boolean boxgaugeIsnotnull;

  /**
   * 箱规(精确搜索)
   */
  private List<String> boxgaugeInList;

  /**
   * CBM(m2)
   */
  private java.math.BigDecimal cbm;

  /**
   * 最小CBM(m2)
   */
  private java.math.BigDecimal cbmMin;

  /**
   * 最大CBM(m2)
   */
  private java.math.BigDecimal cbmMax;

  /**
   * CBM(m2) 比较(eq)
   */
  private java.math.BigDecimal cbmEq;
  /**
   * CBM(m2) 比较(neq)
   */
  private java.math.BigDecimal cbmNeq;
  /**
   * CBM(m2) 比较(gt)
   */
  private java.math.BigDecimal cbmGt;
  /**
   * CBM(m2) 比较(gte)
   */
  private java.math.BigDecimal cbmGte;
  /**
   * CBM(m2) 比较(lt)
   */
  private java.math.BigDecimal cbmLt;
  /**
   * CBM(m2) 比较(lte)
   */
  private java.math.BigDecimal cbmLte;
  /**
   * CBM(m2) 比较(contains)
   */
  private java.math.BigDecimal cbmContains;
  /**
   * CBM(m2) 比较(notcontains)
   */
  private java.math.BigDecimal cbmNotcontains;
  /**
   * CBM(m2) 比较(startswith)
   */
  private java.math.BigDecimal cbmStartswith;
  /**
   * CBM(m2) 比较(endswith)
   */
  private java.math.BigDecimal cbmEndswith;
  /**
   * CBM(m2) 比较(isnull)
   */
  private Boolean cbmIsnull;
  /**
   * CBM(m2) 比较(isnotnull)
   */
  private Boolean cbmIsnotnull;

  /**
   * 体积重(kg)
   */
  private java.math.BigDecimal volumeweight;

  /**
   * 最小体积重(kg)
   */
  private java.math.BigDecimal volumeweightMin;

  /**
   * 最大体积重(kg)
   */
  private java.math.BigDecimal volumeweightMax;

  /**
   * 体积重(kg) 比较(eq)
   */
  private java.math.BigDecimal volumeweightEq;
  /**
   * 体积重(kg) 比较(neq)
   */
  private java.math.BigDecimal volumeweightNeq;
  /**
   * 体积重(kg) 比较(gt)
   */
  private java.math.BigDecimal volumeweightGt;
  /**
   * 体积重(kg) 比较(gte)
   */
  private java.math.BigDecimal volumeweightGte;
  /**
   * 体积重(kg) 比较(lt)
   */
  private java.math.BigDecimal volumeweightLt;
  /**
   * 体积重(kg) 比较(lte)
   */
  private java.math.BigDecimal volumeweightLte;
  /**
   * 体积重(kg) 比较(contains)
   */
  private java.math.BigDecimal volumeweightContains;
  /**
   * 体积重(kg) 比较(notcontains)
   */
  private java.math.BigDecimal volumeweightNotcontains;
  /**
   * 体积重(kg) 比较(startswith)
   */
  private java.math.BigDecimal volumeweightStartswith;
  /**
   * 体积重(kg) 比较(endswith)
   */
  private java.math.BigDecimal volumeweightEndswith;
  /**
   * 体积重(kg) 比较(isnull)
   */
  private Boolean volumeweightIsnull;
  /**
   * 体积重(kg) 比较(isnotnull)
   */
  private Boolean volumeweightIsnotnull;

  /**
   * 单品净重(g)
   */
  private java.math.BigDecimal itemweight;

  /**
   * 最小单品净重(g)
   */
  private java.math.BigDecimal itemweightMin;

  /**
   * 最大单品净重(g)
   */
  private java.math.BigDecimal itemweightMax;

  /**
   * 单品净重(g) 比较(eq)
   */
  private java.math.BigDecimal itemweightEq;
  /**
   * 单品净重(g) 比较(neq)
   */
  private java.math.BigDecimal itemweightNeq;
  /**
   * 单品净重(g) 比较(gt)
   */
  private java.math.BigDecimal itemweightGt;
  /**
   * 单品净重(g) 比较(gte)
   */
  private java.math.BigDecimal itemweightGte;
  /**
   * 单品净重(g) 比较(lt)
   */
  private java.math.BigDecimal itemweightLt;
  /**
   * 单品净重(g) 比较(lte)
   */
  private java.math.BigDecimal itemweightLte;
  /**
   * 单品净重(g) 比较(contains)
   */
  private java.math.BigDecimal itemweightContains;
  /**
   * 单品净重(g) 比较(notcontains)
   */
  private java.math.BigDecimal itemweightNotcontains;
  /**
   * 单品净重(g) 比较(startswith)
   */
  private java.math.BigDecimal itemweightStartswith;
  /**
   * 单品净重(g) 比较(endswith)
   */
  private java.math.BigDecimal itemweightEndswith;
  /**
   * 单品净重(g) 比较(isnull)
   */
  private Boolean itemweightIsnull;
  /**
   * 单品净重(g) 比较(isnotnull)
   */
  private Boolean itemweightIsnotnull;

  /**
   * 单品毛重(g)
   */
  private java.math.BigDecimal itemgrossweight;

  /**
   * 最小单品毛重(g)
   */
  private java.math.BigDecimal itemgrossweightMin;

  /**
   * 最大单品毛重(g)
   */
  private java.math.BigDecimal itemgrossweightMax;

  /**
   * 单品毛重(g) 比较(eq)
   */
  private java.math.BigDecimal itemgrossweightEq;
  /**
   * 单品毛重(g) 比较(neq)
   */
  private java.math.BigDecimal itemgrossweightNeq;
  /**
   * 单品毛重(g) 比较(gt)
   */
  private java.math.BigDecimal itemgrossweightGt;
  /**
   * 单品毛重(g) 比较(gte)
   */
  private java.math.BigDecimal itemgrossweightGte;
  /**
   * 单品毛重(g) 比较(lt)
   */
  private java.math.BigDecimal itemgrossweightLt;
  /**
   * 单品毛重(g) 比较(lte)
   */
  private java.math.BigDecimal itemgrossweightLte;
  /**
   * 单品毛重(g) 比较(contains)
   */
  private java.math.BigDecimal itemgrossweightContains;
  /**
   * 单品毛重(g) 比较(notcontains)
   */
  private java.math.BigDecimal itemgrossweightNotcontains;
  /**
   * 单品毛重(g) 比较(startswith)
   */
  private java.math.BigDecimal itemgrossweightStartswith;
  /**
   * 单品毛重(g) 比较(endswith)
   */
  private java.math.BigDecimal itemgrossweightEndswith;
  /**
   * 单品毛重(g) 比较(isnull)
   */
  private Boolean itemgrossweightIsnull;
  /**
   * 单品毛重(g) 比较(isnotnull)
   */
  private Boolean itemgrossweightIsnotnull;

  /**
   * 单箱重量(kg)
   */
  private java.math.BigDecimal singleitemweight;

  /**
   * 最小单箱重量(kg)
   */
  private java.math.BigDecimal singleitemweightMin;

  /**
   * 最大单箱重量(kg)
   */
  private java.math.BigDecimal singleitemweightMax;

  /**
   * 单箱重量(kg) 比较(eq)
   */
  private java.math.BigDecimal singleitemweightEq;
  /**
   * 单箱重量(kg) 比较(neq)
   */
  private java.math.BigDecimal singleitemweightNeq;
  /**
   * 单箱重量(kg) 比较(gt)
   */
  private java.math.BigDecimal singleitemweightGt;
  /**
   * 单箱重量(kg) 比较(gte)
   */
  private java.math.BigDecimal singleitemweightGte;
  /**
   * 单箱重量(kg) 比较(lt)
   */
  private java.math.BigDecimal singleitemweightLt;
  /**
   * 单箱重量(kg) 比较(lte)
   */
  private java.math.BigDecimal singleitemweightLte;
  /**
   * 单箱重量(kg) 比较(contains)
   */
  private java.math.BigDecimal singleitemweightContains;
  /**
   * 单箱重量(kg) 比较(notcontains)
   */
  private java.math.BigDecimal singleitemweightNotcontains;
  /**
   * 单箱重量(kg) 比较(startswith)
   */
  private java.math.BigDecimal singleitemweightStartswith;
  /**
   * 单箱重量(kg) 比较(endswith)
   */
  private java.math.BigDecimal singleitemweightEndswith;
  /**
   * 单箱重量(kg) 比较(isnull)
   */
  private Boolean singleitemweightIsnull;
  /**
   * 单箱重量(kg) 比较(isnotnull)
   */
  private Boolean singleitemweightIsnotnull;

  /**
   * 单箱毛重
   */
  private java.math.BigDecimal singleboxweight;

  /**
   * 最小单箱毛重
   */
  private java.math.BigDecimal singleboxweightMin;

  /**
   * 最大单箱毛重
   */
  private java.math.BigDecimal singleboxweightMax;

  /**
   * 单箱毛重 比较(eq)
   */
  private java.math.BigDecimal singleboxweightEq;
  /**
   * 单箱毛重 比较(neq)
   */
  private java.math.BigDecimal singleboxweightNeq;
  /**
   * 单箱毛重 比较(gt)
   */
  private java.math.BigDecimal singleboxweightGt;
  /**
   * 单箱毛重 比较(gte)
   */
  private java.math.BigDecimal singleboxweightGte;
  /**
   * 单箱毛重 比较(lt)
   */
  private java.math.BigDecimal singleboxweightLt;
  /**
   * 单箱毛重 比较(lte)
   */
  private java.math.BigDecimal singleboxweightLte;
  /**
   * 单箱毛重 比较(contains)
   */
  private java.math.BigDecimal singleboxweightContains;
  /**
   * 单箱毛重 比较(notcontains)
   */
  private java.math.BigDecimal singleboxweightNotcontains;
  /**
   * 单箱毛重 比较(startswith)
   */
  private java.math.BigDecimal singleboxweightStartswith;
  /**
   * 单箱毛重 比较(endswith)
   */
  private java.math.BigDecimal singleboxweightEndswith;
  /**
   * 单箱毛重 比较(isnull)
   */
  private Boolean singleboxweightIsnull;
  /**
   * 单箱毛重 比较(isnotnull)
   */
  private Boolean singleboxweightIsnotnull;

  /**
   * 总净重
   */
  private java.math.BigDecimal totalweight;

  /**
   * 最小总净重
   */
  private java.math.BigDecimal totalweightMin;

  /**
   * 最大总净重
   */
  private java.math.BigDecimal totalweightMax;

  /**
   * 总净重 比较(eq)
   */
  private java.math.BigDecimal totalweightEq;
  /**
   * 总净重 比较(neq)
   */
  private java.math.BigDecimal totalweightNeq;
  /**
   * 总净重 比较(gt)
   */
  private java.math.BigDecimal totalweightGt;
  /**
   * 总净重 比较(gte)
   */
  private java.math.BigDecimal totalweightGte;
  /**
   * 总净重 比较(lt)
   */
  private java.math.BigDecimal totalweightLt;
  /**
   * 总净重 比较(lte)
   */
  private java.math.BigDecimal totalweightLte;
  /**
   * 总净重 比较(contains)
   */
  private java.math.BigDecimal totalweightContains;
  /**
   * 总净重 比较(notcontains)
   */
  private java.math.BigDecimal totalweightNotcontains;
  /**
   * 总净重 比较(startswith)
   */
  private java.math.BigDecimal totalweightStartswith;
  /**
   * 总净重 比较(endswith)
   */
  private java.math.BigDecimal totalweightEndswith;
  /**
   * 总净重 比较(isnull)
   */
  private Boolean totalweightIsnull;
  /**
   * 总净重 比较(isnotnull)
   */
  private Boolean totalweightIsnotnull;

  /**
   * 生成货件
   */
  private String generateshipment;

  /**
   * 生成货件 比较(eq)
   */
  private String generateshipmentEq;
  /**
   * 生成货件 比较(neq)
   */
  private String generateshipmentNeq;
  /**
   * 生成货件 比较(gt)
   */
  private String generateshipmentGt;
  /**
   * 生成货件 比较(gte)
   */
  private String generateshipmentGte;
  /**
   * 生成货件 比较(lt)
   */
  private String generateshipmentLt;
  /**
   * 生成货件 比较(lte)
   */
  private String generateshipmentLte;
  /**
   * 生成货件 比较(contains)
   */
  private String generateshipmentContains;
  /**
   * 生成货件 比较(notcontains)
   */
  private String generateshipmentNotcontains;
  /**
   * 生成货件 比较(startswith)
   */
  private String generateshipmentStartswith;
  /**
   * 生成货件 比较(endswith)
   */
  private String generateshipmentEndswith;
  /**
   * 生成货件 比较(isnull)
   */
  private Boolean generateshipmentIsnull;
  /**
   * 生成货件 比较(isnotnull)
   */
  private Boolean generateshipmentIsnotnull;

  /**
   * 生成货件(精确搜索)
   */
  private List<String> generateshipmentInList;

  /**
   * fnskuname(模糊搜索)
   */
  private String fnskuname;

  /**
   * fnskuname 比较(eq)
   */
  private String fnskunameEq;
  /**
   * fnskuname 比较(neq)
   */
  private String fnskunameNeq;
  /**
   * fnskuname 比较(gt)
   */
  private String fnskunameGt;
  /**
   * fnskuname 比较(gte)
   */
  private String fnskunameGte;
  /**
   * fnskuname 比较(lt)
   */
  private String fnskunameLt;
  /**
   * fnskuname 比较(lte)
   */
  private String fnskunameLte;
  /**
   * fnskuname 比较(contains)
   */
  private String fnskunameContains;
  /**
   * fnskuname 比较(notcontains)
   */
  private String fnskunameNotcontains;
  /**
   * fnskuname 比较(startswith)
   */
  private String fnskunameStartswith;
  /**
   * fnskuname 比较(endswith)
   */
  private String fnskunameEndswith;
  /**
   * fnskuname 比较(isnull)
   */
  private Boolean fnskunameIsnull;
  /**
   * fnskuname 比较(isnotnull)
   */
  private Boolean fnskunameIsnotnull;

  /**
   * fnskuname(精确搜索)
   */
  private List<String> fnskunameInList;

  /**
   * 标题(模糊搜索)
   */
  private String title;

  /**
   * 标题 比较(eq)
   */
  private String titleEq;
  /**
   * 标题 比较(neq)
   */
  private String titleNeq;
  /**
   * 标题 比较(gt)
   */
  private String titleGt;
  /**
   * 标题 比较(gte)
   */
  private String titleGte;
  /**
   * 标题 比较(lt)
   */
  private String titleLt;
  /**
   * 标题 比较(lte)
   */
  private String titleLte;
  /**
   * 标题 比较(contains)
   */
  private String titleContains;
  /**
   * 标题 比较(notcontains)
   */
  private String titleNotcontains;
  /**
   * 标题 比较(startswith)
   */
  private String titleStartswith;
  /**
   * 标题 比较(endswith)
   */
  private String titleEndswith;
  /**
   * 标题 比较(isnull)
   */
  private Boolean titleIsnull;
  /**
   * 标题 比较(isnotnull)
   */
  private Boolean titleIsnotnull;

  /**
   * 标题(精确搜索)
   */
  private List<String> titleInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
